home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / dev / sun4c.md / devSCSIC90.c < prev    next >
C/C++ Source or Header  |  1991-08-01  |  49KB  |  1,790 lines
  1. /* 
  2.  * devSCSIC90.c --
  3.  *
  4.  *    Routines specific to the SCSI NCR 53C9X Host Adaptor.  This adaptor is
  5.  *    based on the NCR 53C90 chip.
  6.  *    The 53C90 supports connect/dis-connect.
  7.  *
  8.  * Copyright 1988 Regents of the University of California
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  */
  17.  
  18. #ifndef lint
  19. static char rcsid[] = "$Header: /sprite/src/kernel/dev/ds5000.md/RCS/devSCSIC90.c,v 1.5 91/08/01 20:57:44 mottsmth Exp $ SPRITE (Berkeley)";
  20. #endif /* not lint */
  21.  
  22. #include "sprite.h"
  23. #include "scsiC90.h"
  24. #include "mach.h"
  25. #include "dev.h"
  26. #include "scsiHBA.h"
  27. #include "scsiDevice.h"
  28. #include "sync.h"
  29. #include "stdio.h"
  30. #include "stdlib.h"
  31. #include "string.h"
  32. #include "bstring.h"
  33. #include "devSCSIC90.h"
  34. #include "devSCSIC90Int.h"
  35.  
  36. /*
  37.  * Forward declarations.  
  38.  */
  39.  
  40. static void        PrintMsg _ARGS_ ((unsigned int msg));
  41. static void        PrintPhase _ARGS_ ((unsigned int phase));
  42. static void        PrintLastPhase _ARGS_ ((unsigned int phase));
  43. static ReturnStatus     SendCommand _ARGS_ ((Device *devPtr,
  44.                                              ScsiCmd *scsiCmdPtr));
  45. static void             PrintRegs _ARGS_((volatile CtrlRegs *regsPtr));
  46. static void             PerformCmdDone _ARGS_((Controller *ctrlPtr,
  47.                            ReturnStatus status));
  48. static ReturnStatus     PerformSelect _ARGS_((Controller *ctrlPtr,
  49.                           unsigned int interruptReg,
  50.                           unsigned int sequenceReg));
  51. static ReturnStatus     PerformDataXfer _ARGS_((Controller *ctrlPtr,
  52.                           unsigned int interruptReg,
  53.                           unsigned int statusReg));
  54. static ReturnStatus     PerformStatus _ARGS_((Controller *ctrlPtr,
  55.                           unsigned int interruptReg));
  56. static ReturnStatus     PerformMsgIn _ARGS_(( Controller *ctrlPtr));
  57. static ReturnStatus     PerformReselect _ARGS_(( Controller *ctrlPtr,
  58.                           unsigned int interruptReg));
  59. static ReturnStatus     PerformExtendedMsgIn _ARGS_(( Controller *ctrlPtr,
  60.                           unsigned int message));
  61. static int              SpecialSenseProc _ARGS_((void));
  62. static void             PutCircBuf _ARGS_((int type, char *object));
  63.  
  64. /*
  65.  * devSCSIC90Debug - debugging level
  66.  *    2 - normal level
  67.  *    4 - one print per command in the normal case
  68.  *    5 - traces interrupts
  69.  */
  70. int devSCSIC90Debug = 2;
  71. Controller *Controllers[MAX_SCSIC90_CTRLS];
  72.  
  73. char        circBuf[CIRCBUFLEN] = {""};
  74. int         circHead = 0;
  75. char numTab[16] = {
  76.     '0', '1', '2', '3', '4', '5', '6', '7',
  77.     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
  78.     };
  79.      
  80.  
  81.  
  82. /*
  83.  *----------------------------------------------------------------------
  84.  *
  85.  * SendCommand --
  86.  *
  87.  *      Send a command to a SCSI controller.
  88.  *    NOTE: The caller is assumed to have the master lock of the controller
  89.  *    to which the device is attached held.
  90.  *      
  91.  *
  92.  * Results:
  93.  *    An error code.
  94.  *
  95.  * Side effects:
  96.  *    Those of the command (Read, write etc.)
  97.  *
  98.  *----------------------------------------------------------------------
  99.  */
  100. static ReturnStatus
  101. SendCommand(devPtr, scsiCmdPtr)
  102.     Device     *devPtr;        /* Device to sent to. */
  103.     ScsiCmd    *scsiCmdPtr;        /* Command to send. */
  104. {
  105.     volatile CtrlRegs    *regsPtr; /* Host Adaptor registers */
  106.     char    *charPtr;
  107.     Controller    *ctrlPtr;
  108.     int i;
  109.     int size;                /* Number of bytes to transfer */
  110.  
  111.     /*
  112.      * Set current active device and command for this controller.
  113.      */
  114.     ctrlPtr = devPtr->ctrlPtr;
  115.     regsPtr = ctrlPtr->regsPtr;
  116.  
  117.     if (ctrlPtr->devPtr != (Device *)NIL) {
  118.     panic("SCSIC90Command: can't send: host is busy\n");
  119.     }
  120.  
  121.     SET_CTRL_BUSY(ctrlPtr,devPtr);
  122.     SET_DEV_BUSY(devPtr, scsiCmdPtr);
  123.  
  124.     devPtr->scsiCmdPtr   = scsiCmdPtr;
  125.     size = scsiCmdPtr->bufferLen;
  126.     if (size == 0) {
  127.     devPtr->dmaState = DMA_INACTIVE;
  128.     } else {
  129.     devPtr->dmaState = (scsiCmdPtr->dataToDevice) ? DMA_SEND :
  130.                             DMA_RECEIVE;
  131.     }
  132.  
  133.     PUTCIRCBUF(CSTR, "send: targ ");
  134.     PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  135.     PUTCIRCBUF(CSTR, ";cmd ");
  136.     PUTCIRCBUF(CINT, (char *)scsiCmdPtr);
  137.     PUTCIRCBUF(CSTR,";buf ");
  138.     PUTCIRCBUF(CINT, (char *)scsiCmdPtr->buffer);
  139.     PUTCIRCBUF(CSTR, ";len ");
  140.     PUTCIRCBUF(CINT, (char *)size);
  141.     PUTCIRCBUF(CSTR,";op ");
  142.     PUTCIRCBUF(CBYTE, (char *)scsiCmdPtr->commandBlock[0]);
  143.     PUTCIRCNULL;
  144.  
  145.     /*
  146.      * SCSI SELECTION.
  147.      */
  148.  
  149.     /*
  150.      * Set phase to selection and command phase so that we know what's happened
  151.      * in the next phase.
  152.      */
  153.     devPtr->lastPhase = PHASE_SELECTION;    /* Selection & command phase.*/
  154.     devPtr->commandStatus = 0;            /* No status yet. */
  155.     devPtr->activeBufPtr = scsiCmdPtr->buffer;
  156.     devPtr->activeBufLen = scsiCmdPtr->bufferLen;
  157.     /* Load select/reselect bus ID register with target ID. */
  158.     regsPtr->scsi_ctrl.write.destID = devPtr->targetID;
  159.     /* Load select/reselect timeout period. */
  160.     regsPtr->scsi_ctrl.write.timeout = SELECT_TIMEOUT;
  161.     /* Zero value for asynchronous transfer. */
  162.     regsPtr->scsi_ctrl.write.synchOffset = devPtr->synchOffset;
  163.     if (devPtr->synchOffset != 0) {
  164.     regsPtr->scsi_ctrl.write.synchPer = devPtr->synchPeriod;
  165.     }
  166.     /* Set the clock conversion register. */
  167.     regsPtr->scsi_ctrl.write.clockConv = CLOCKCONV;
  168.  
  169.     EMPTY_BUFFER();
  170.  
  171.     /* 
  172.      * There are 3 selection possibilities:
  173.      * 1) Without Attention (NATN) which says we don't do disconnect/reselect.
  174.      *    No need to use this anymore.
  175.      * 2) With Attention (ATN) which goes through arbitration, selection
  176.      *    and command phases, announcing that we do disconnect/reselect.
  177.      *    The usual mode.
  178.      * 3) With attention and stop (ATNS) which just goes through 
  179.      *    arbitration and selection phases and stops.  This gives
  180.      *    us a chance to send another message after the IDENTIFY msg
  181.      *    before sending the command.  For use in sending the 1st
  182.      *    message of the synchronous data xfer negotiation.
  183.      */
  184.  
  185.     if (scsiCmdPtr->commandBlockLen != 6 &&
  186.     scsiCmdPtr->commandBlockLen != 10 &&
  187.     scsiCmdPtr->commandBlockLen != 12) {
  188.     printf("%s: Command is wrong length.\n");
  189.     PUTCIRCBUF(CSTR,"send: bad cmd len\n");
  190.     PUTCIRCNULL;
  191.     return DEV_INVALID_ARG;     /* Is this the correct error? */
  192.     }
  193.  
  194.  
  195.     regsPtr->scsi_ctrl.write.FIFO = SCSI_DIS_REC_IDENTIFY | devPtr->handle.LUN;
  196.  
  197.     if ((devPtr->synchPeriod < MIN_SYNCH_PERIOD) &&
  198.     (devPtr->msgFlag & ENABLEEXTENDEDMSG)) {
  199.     devPtr->msgFlag |= REQEXTENDEDMSG;
  200.     EMPTY_BUFFER();
  201.     regsPtr->scsi_ctrl.write.command = CR_SLCT_ATNS;
  202.     PUTCIRCBUF(CSTR,"send ATNS; per ");
  203.     } else {
  204.     /* Load FIFO with 6, 10, or 12 byte scsi command. */
  205.     charPtr = scsiCmdPtr->commandBlock;
  206.     for (i = 0; i < scsiCmdPtr->commandBlockLen; i++) {
  207.         regsPtr->scsi_ctrl.write.FIFO = *charPtr;
  208.         charPtr++;
  209.     }
  210.     PUTCIRCBUF(CSTR,"send ATN; per ");
  211.     EMPTY_BUFFER();
  212.     regsPtr->scsi_ctrl.write.command = CR_SLCT_ATN;
  213.     }
  214.     PUTCIRCBUF(CBYTE,(char *)(devPtr->synchPeriod));
  215.     PUTCIRCBUF(CSTR,"; off ");
  216.     PUTCIRCBUF(CBYTE,(char *)(devPtr->synchOffset));
  217.     PUTCIRCBUF(CSTR,"; cmd ");
  218.     PUTCIRCBUF(CBYTE,(char *)(*scsiCmdPtr->commandBlock));
  219.     PUTCIRCNULL;
  220.  
  221.     return SUCCESS;
  222. }
  223.  
  224.  
  225. /*
  226.  *----------------------------------------------------------------------
  227.  *
  228.  * RequestDone --
  229.  *
  230.  *    Process a request that has finished. Unless a SCSI check condition
  231.  *    bit is present in the status returned, the request call back
  232.  *    function is called.  If check condition is set we fire off a
  233.  *    SCSI REQUEST SENSE to get the error sense bytes from the device.
  234.  *
  235.  * Results:
  236.  *    None.
  237.  *
  238.  * Side effects:
  239.  *    The call back function may be called.
  240.  *
  241.  *----------------------------------------------------------------------
  242.  */
  243.  
  244. static void
  245. RequestDone(devPtr,scsiCmdPtr,status,scsiStatusByte,amountTransferred)
  246.     Device    *devPtr;    /* Device for request. */
  247.     ScsiCmd    *scsiCmdPtr;    /* Request that finished. */
  248.     ReturnStatus status;    /* Status returned. */
  249.     unsigned char scsiStatusByte;    /* SCSI Status Byte. */
  250.     int        amountTransferred; /* Amount transferred by command. */
  251. {
  252.     ReturnStatus    senseStatus;
  253.     Controller            *ctrlPtr = devPtr->ctrlPtr;
  254.     int i;
  255.  
  256.     PUTCIRCBUF(CSTR,"done: targ ");
  257.     PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  258.     PUTCIRCBUF(CSTR,";rc ");
  259.     PUTCIRCBUF(CBYTE, (char *)status);
  260.     PUTCIRCBUF(CSTR,";stat ");
  261.     PUTCIRCBUF(CBYTE, (char *)scsiStatusByte);
  262.     PUTCIRCBUF(CSTR,";cnt ");
  263.     PUTCIRCBUF(CBYTE, (char *)amountTransferred);
  264.     PUTCIRCNULL;
  265.  
  266.     SET_CTRL_FREE(ctrlPtr);
  267.  
  268.     /*
  269.      * First check to see if this is the reponse of a HBA-driver generated 
  270.      * REQUEST SENSE command.  If this is the case, we can process
  271.      * the callback of the frozen command for this device and
  272.      * allow the flow of command to the device to be resummed.
  273.      */
  274.     if (scsiCmdPtr->doneProc == SpecialSenseProc) {
  275.     PUTCIRCBUF(CSTR,"sense data:");
  276.     for (i=0; i<amountTransferred; i++) {
  277.         circBuf[circHead] = ' ';
  278.         circHead = (circHead + 1) % CIRCBUFLEN;
  279.         PUTCIRCBUF(CBYTE, (char *)(devPtr->senseBuffer[i]));
  280.     }
  281.     PUTCIRCNULL;
  282.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  283.     (devPtr->frozen.scsiCmdPtr->doneProc)(devPtr->frozen.scsiCmdPtr, 
  284.         SUCCESS,
  285.         devPtr->frozen.statusByte, 
  286.         devPtr->frozen.amountTransferred,
  287.         amountTransferred,
  288.         devPtr->senseBuffer);
  289.          MASTER_LOCK(&(ctrlPtr->mutex));
  290.      SET_DEV_FREE(devPtr);
  291.      return;
  292.     }
  293.     /*
  294.      * This must be an outside request finishing. If the request 
  295.      * suffered an error or the HBA or the scsi status byte
  296.      * says there is no error sense present, we can do the
  297.      * callback and free the controller.
  298.      */
  299.     if ((status != SUCCESS) ||
  300.     (scsiStatusByte != SCSI_STATUS_CHECK)) { 
  301.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  302.     PUTCIRCBUF(CSTR,"done: callback before...");
  303.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  304.                    amountTransferred, 0, (char *) 0);
  305.     MASTER_LOCK(&(ctrlPtr->mutex));
  306.     PUTCIRCBUF(CSTR,"after");
  307.     PUTCIRCNULL;
  308.     SET_DEV_FREE(devPtr);
  309.     return;
  310.     } 
  311.     /*
  312.      * If we got here than the SCSI command came back from the device
  313.      * with the CHECK bit set in the status byte.
  314.      * Need to perform a REQUEST SENSE.  Move the current request 
  315.      * into the frozen state and issue a REQUEST SENSE. 
  316.      */
  317.  
  318.     PUTCIRCBUF(CSTR,"done: issue sense");
  319.     PUTCIRCNULL;
  320.     devPtr->synchPeriod = 0;
  321.     devPtr->synchOffset = 0;
  322.     devPtr->frozen.scsiCmdPtr = scsiCmdPtr;
  323.     devPtr->frozen.statusByte = scsiStatusByte;
  324.     devPtr->frozen.amountTransferred = amountTransferred;
  325.     DevScsiSenseCmd((ScsiDevice *)devPtr, DEV_MAX_SENSE_BYTES, 
  326.             devPtr->senseBuffer, &(devPtr->SenseCmd));
  327.     devPtr->SenseCmd.doneProc = SpecialSenseProc;
  328.     senseStatus = SendCommand(devPtr, &(devPtr->SenseCmd));
  329.     
  330.    /*
  331.      * If we got an HBA error on the REQUEST SENSE we end the outside 
  332.      * command with the SUCCESS status but zero sense bytes returned.
  333.      */
  334.     if (senseStatus != SUCCESS) {
  335.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  336.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  337.                    amountTransferred, 0, (char *) 0);
  338.         MASTER_LOCK(&(ctrlPtr->mutex));
  339.     SET_DEV_FREE(devPtr);
  340.     }
  341.  
  342. }
  343.  
  344. /*
  345.  *----------------------------------------------------------------------
  346.  *
  347.  * DevEntryAvailProc --
  348.  *
  349.  *    Act upon an entry becomming available in the queue for this
  350.  *    controller. This routine is the Dev_Queue callback function that
  351.  *    is called whenever work becomes available for this controller. 
  352.  *    If the controller is not already busy we dequeue and start the
  353.  *    request.
  354.  *    NOTE: This routine is also called from DevSCSIC90Intr to start the
  355.  *    next request after the previously one finishes.
  356.  *
  357.  * Results:
  358.  *    None.
  359.  *
  360.  * Side effects:
  361.  *    Request may be dequeue and submitted to the device. Request callback
  362.  *    function may be called.
  363.  *
  364.  *----------------------------------------------------------------------
  365.  */
  366.  
  367. Boolean
  368. DevEntryAvailProc(clientData, newRequestPtr) 
  369.    ClientData    clientData;    /* Really the Device this request ready. */
  370.    List_Links *newRequestPtr;    /* The new SCSI request. */
  371. {
  372.     Device        *devPtr; 
  373.     Controller         *ctrlPtr;
  374.     ScsiCmd        *scsiCmdPtr = (ScsiCmd *)newRequestPtr;
  375.     ReturnStatus    status;
  376.  
  377.     devPtr = (Device *) clientData;
  378.     ctrlPtr = devPtr->ctrlPtr;
  379.     /*
  380.      * If we are busy (have an active request) just return. Otherwise 
  381.      * start the request.
  382.      */
  383.     
  384.     if ((IS_CTRL_FREE(ctrlPtr)) &&  (IS_DEV_FREE(devPtr))) {
  385.     PUTCIRCBUF(CSTR,"EAP: exec targ ");
  386.     PUTCIRCBUF(CBYTE, (char *)(devPtr->targetID));
  387.     PUTCIRCBUF(CSTR,"; mask ");
  388.     PUTCIRCBUF(CBYTE, (char *)(ctrlPtr->devQueuesMask));
  389.     PUTCIRCBUF(CSTR,"; cmd ptr ");
  390.     PUTCIRCBUF(CINT, (char *)newRequestPtr);
  391.     PUTCIRCNULL;
  392.     } else {
  393.     PUTCIRCBUF(CSTR,"EAP: NQ targ ");
  394.     PUTCIRCBUF(CBYTE, (char *)(devPtr->targetID));
  395.     PUTCIRCBUF(CSTR,"; mask ");
  396.     PUTCIRCBUF(CBYTE, (char *)(ctrlPtr->devQueuesMask));
  397.     PUTCIRCBUF(CSTR,"; cmd ptr ");
  398.     PUTCIRCBUF(CINT,(char *)newRequestPtr);
  399.     PUTCIRCBUF(CSTR,"; intDev ");
  400.     PUTCIRCBUF(CINT,(char *)(ctrlPtr->interruptDevPtr));
  401.     if (ctrlPtr->interruptDevPtr != (Device *)NIL) {
  402.         PUTCIRCBUF(CSTR,"; intDevCmd ");
  403.         PUTCIRCBUF(CINT,(char *)(ctrlPtr->interruptDevPtr->scsiCmdPtr));
  404.     }
  405.     PUTCIRCNULL;
  406.     return FALSE;
  407.     }
  408.  
  409. again:
  410.     scsiCmdPtr = (ScsiCmd *) newRequestPtr;
  411.     devPtr = (Device *) clientData;
  412.     status = SendCommand(devPtr, scsiCmdPtr);
  413.  
  414.     /*    
  415.      * If the command couldn't be started do the callback function.
  416.      */
  417.     if (status != SUCCESS) {
  418.      PUTCIRCBUF(CSTR,"eap: send fail");
  419.      PUTCIRCNULL;
  420.      RequestDone(devPtr,scsiCmdPtr,status,0,0);
  421.      newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  422.                          ctrlPtr->devQueuesMask,
  423.                          &clientData);
  424.     if (newRequestPtr != (List_Links *) NIL) { 
  425.         PUTCIRCBUF(CSTR,"eap: no cmd");
  426.         PUTCIRCNULL;
  427.         goto again;
  428.     } else {
  429.         PUTCIRCBUF(CSTR,"eap: cmd");
  430.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  431.         PUTCIRCNULL;
  432.     }
  433.     }
  434.  
  435.     return TRUE;
  436.  
  437. }   
  438.  
  439.  
  440. /*
  441.  *----------------------------------------------------------------------
  442.  *
  443.  * DevSCSIC90Intr --
  444.  *
  445.  * Handle interrupts from the SCSI controller.
  446.  *
  447.  * Results:
  448.  *    TRUE if an SCSIC90 controller was responsible for the interrupt
  449.  *    and this routine handled it.
  450.  *
  451.  * Side effects:
  452.  *    Usually a process is notified that an I/O has completed.
  453.  *      Extreme headaches from trying to follow this absurd code.
  454.  * 
  455.  * Note:
  456.  *      Cannot use printf for debugging in this routine since 
  457.  *      printf re-enables interrupts.
  458.  *
  459.  *----------------------------------------------------------------------
  460.  */
  461. Boolean 
  462. DevSCSIC90Intr(clientDataArg)
  463.     ClientData    clientDataArg;
  464. {
  465.     Controller        *ctrlPtr;
  466.     volatile CtrlRegs    *regsPtr;
  467.     Device        *devPtr;
  468.     unsigned char    phase;
  469.     ReturnStatus    status = SUCCESS;
  470.     unsigned char    interruptReg;
  471.     unsigned char    statusReg;
  472.     unsigned char    sequenceReg;
  473.     int                 i;
  474.     char            *charPtr;
  475.     char            tempChar;
  476.  
  477.     ctrlPtr = (Controller *) clientDataArg;
  478.     regsPtr = ctrlPtr->regsPtr;
  479.     devPtr = ctrlPtr->devPtr;
  480.  
  481.     MASTER_LOCK(&(ctrlPtr->mutex));
  482.  
  483.     /* Read registers.
  484.      * reading the interrupt register clears the status and sequence
  485.      * registers so it must be read last.
  486.      */
  487.     statusReg = regsPtr->scsi_ctrl.read.status;
  488.     sequenceReg = regsPtr->scsi_ctrl.read.sequence;
  489.     interruptReg = regsPtr->scsi_ctrl.read.interrupt;
  490.     phase = statusReg & SR_PHASE;
  491.     sequenceReg &= SEQ_MASK;
  492.  
  493.     PUTCIRCBUF(CSTR,"intr: dev ");
  494.     PUTCIRCBUF(CINT,(char *)devPtr);
  495.     PUTCIRCBUF(CSTR,";int ");
  496.     PUTCIRCBUF(CBYTE, (char *)interruptReg);
  497.     PUTCIRCBUF(CSTR,";stat ");
  498.     PUTCIRCBUF(CBYTE, (char *)statusReg);
  499.     PUTCIRCBUF(CSTR,";seq ");
  500.     PUTCIRCBUF(CBYTE, (char *)sequenceReg);
  501.     if (devPtr != (Device *)NIL) {
  502.     PUTCIRCBUF(CSTR,";last ");
  503.     PUTCIRCBUF(CBYTE, (char *)devPtr->lastPhase);
  504.     }
  505.     PUTCIRCNULL;
  506.  
  507. /*    printf("interruptReg 0x%02x, statusReg 0x%02x, sequenceReg 0x%02x\n",
  508.         interruptReg, statusReg, sequenceReg);
  509. */
  510.     /* Check for errors. */
  511.     if (statusReg & SR_GE) {
  512.     panic("gross error 1\n");
  513.     printf("%s: some gross error happened.\n",
  514.         devPtr->handle.locationName);
  515.     status = FAILURE;
  516.     }
  517.     if (statusReg & SR_PE) {
  518.     printf("%s: a parity error happened.\n",
  519.         devPtr->handle.locationName);
  520.     status = FAILURE;
  521.     }
  522.  
  523.     if (interruptReg & IR_SCSI_RST) {
  524.     printf("%s: SCSI reset detected.\n",
  525.         devPtr->handle.locationName);
  526.     status = FAILURE;
  527.     }
  528.     if (interruptReg & IR_ILL_CMD) {
  529.     if (ctrlPtr->interruptDevPtr != (Device *)NIL) {
  530.         PUTCIRCBUF(CSTR,"ignoring illegal cmd interrupt");
  531.         PUTCIRCNULL;
  532.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  533.         return TRUE;
  534.     } else {
  535.         printf("%s: illegal command.\n",
  536.            devPtr->handle.locationName);
  537.         status = FAILURE;
  538.     }
  539.     }
  540.     if (interruptReg & IR_SLCT_ATN) {
  541.     printf("%s: scsi controller selected with ATN which we don't allow.\n",
  542.         devPtr->handle.locationName);
  543.     status = FAILURE;
  544.     }
  545.     if (interruptReg & IR_SLCT) {
  546.     printf("%s: scsi controller selected as target which we don't allow.\n",
  547.         devPtr->handle.locationName);
  548.     status = FAILURE;
  549.     }
  550.     if (interruptReg & IR_RESLCT) {
  551.     PerformReselect(ctrlPtr, interruptReg);
  552.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  553.     return TRUE;
  554.     }
  555.     if (IS_CTRL_FREE(ctrlPtr)) {
  556.     if (status == SUCCESS)
  557.         panic("SCSIC90: Got interrupt but ctrl is free.\n");
  558.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  559.     return TRUE;
  560.     }
  561.  
  562.  
  563.     /* Where did we come from? */
  564.     switch (devPtr->lastPhase) {
  565.     case PHASE_COMMAND:
  566.     break;
  567.     case PHASE_BUS_FREE:
  568.     /* nothing happening yet. */
  569.     break;
  570.     case PHASE_SELECTION:
  571.     status = PerformSelect(ctrlPtr, interruptReg, sequenceReg);
  572.     break;
  573.     case PHASE_DATA_IN:
  574. #ifdef sun4c
  575.     /* Drain remaining bytes in pack register to memory. */
  576.     dmaRegsPtr->ctrl |= DMA_DRAIN;
  577. #endif
  578.     status = PerformDataXfer(ctrlPtr, interruptReg, statusReg);
  579.     break;
  580.     case PHASE_DATA_OUT:
  581.     status = PerformDataXfer(ctrlPtr, interruptReg, statusReg);
  582.     break;
  583.     case PHASE_STATUS:
  584.     status = PerformStatus(ctrlPtr, interruptReg);
  585.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  586.     return TRUE;
  587.     break;
  588.     case PHASE_MSG_OUT:
  589.     break;
  590.     case PHASE_MSG_IN:
  591.     status = PerformMsgIn(ctrlPtr);
  592.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  593.     return TRUE;
  594.     break;
  595.     case PHASE_STAT_MSG_IN:
  596.     if (!(interruptReg & IR_DISCNCT)) {
  597.         printf("SCSIC90: Should have seen end of I/O.\n");
  598.         status = FAILURE;
  599.     }
  600.     break;
  601.     case PHASE_RDY_DISCON:
  602.     if (interruptReg & IR_DISCNCT) {
  603.         PUTCIRCBUF(CSTR,"intr: targ ");
  604.         PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  605.         PUTCIRCBUF(CSTR," discon.");
  606.         PUTCIRCNULL;
  607.         devPtr->lastPhase = PHASE_BUS_FREE;
  608.         SET_CTRL_FREE(ctrlPtr);
  609.         PerformCmdDone(ctrlPtr,status);
  610.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  611.         return TRUE;
  612.     } else {
  613.         printf("SCSIC90: expecting disconnect signal.\n");
  614.         status = FAILURE;
  615.     }
  616.     break;
  617.     default:
  618.     /* We set this field, so this shouldn't happen. */
  619.     printf("SCSIC90Intr: We came from an unknown phase.\n");
  620.     status = FAILURE;
  621.     break;
  622.     }
  623.  
  624.     if ((status != SUCCESS) || (interruptReg & IR_DISCNCT)) {
  625.         PUTCIRCBUF(CSTR,"intr: exit stat ");
  626.         PUTCIRCBUF(CBYTE,(char *)status);
  627.         PUTCIRCNULL;
  628.     RequestDone(devPtr,
  629.             devPtr->scsiCmdPtr,
  630.             status,
  631.             devPtr->commandStatus,
  632.             devPtr->scsiCmdPtr->bufferLen - devPtr->activeBufLen);
  633.     PerformCmdDone(ctrlPtr,status);
  634.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  635.     return TRUE;
  636.     }
  637.  
  638.     switch (phase) {
  639.  
  640.     case SR_DATA_OUT:
  641.     case SR_DATA_IN:
  642.     devPtr->lastPhase = (phase == SR_DATA_OUT ? PHASE_DATA_OUT :
  643.                  PHASE_DATA_IN);
  644.     /*
  645.      * It should be possible to do multiple blocks of DMA without
  646.      * returning to the higher level, if we set the max transfer size
  647.      * larger, but we don't handle that yet. XXX
  648.      */
  649. #ifdef sun4c
  650.     dmaControllerActive++;    /* Resetting controller not allowed. */
  651. #endif
  652.     PUTCIRCBUF(CSTR,"start dma ptr: ");
  653.     PUTCIRCBUF(CINT,(char *)devPtr->activeBufPtr);
  654.     PUTCIRCBUF(CSTR,"; len: ");
  655.     PUTCIRCBUF(CINT,(char *)devPtr->activeBufLen);
  656.     PUTCIRCNULL;
  657.     DevStartDMA(ctrlPtr);
  658.     break;
  659.     case SR_COMMAND:
  660.     charPtr = devPtr->scsiCmdPtr->commandBlock;
  661.     PUTCIRCBUF(CSTR,"cmd:");
  662.     for (i = 0; i < devPtr->scsiCmdPtr->commandBlockLen; i++) {
  663.         circBuf[circHead] = ' ';
  664.         circHead = (circHead + 1) % CIRCBUFLEN;
  665.         PUTCIRCBUF(CBYTE, (char *)*charPtr);
  666.         regsPtr->scsi_ctrl.write.FIFO = *charPtr;
  667.         charPtr++;
  668.     }
  669.     PUTCIRCNULL;
  670.     devPtr->lastPhase = PHASE_COMMAND;
  671.     regsPtr->scsi_ctrl.write.synchPer = devPtr->synchPeriod;
  672.     regsPtr->scsi_ctrl.write.synchOffset = devPtr->synchOffset;
  673.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  674.     break;
  675.     case SR_STATUS:
  676.     /*
  677.      * We're in status phase.  If all goes right, the next interrupt
  678.      * will be after we've handled the message phase as well, although
  679.      * the phase will say we're in message phase.
  680.      */
  681.     devPtr->lastPhase = PHASE_STATUS;
  682.     regsPtr->scsi_ctrl.write.command = CR_INIT_COMP;
  683.     break;
  684.     case SR_MSG_OUT:
  685.     i = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  686.     if (i > 0) {
  687.         PUTCIRCBUF(CSTR,"msg-out: fifo: ");
  688.         while (i-- > 0) {
  689.         circBuf[circHead] = ' ';
  690.         circHead = (circHead + 1) % CIRCBUFLEN;
  691.         tempChar = regsPtr->scsi_ctrl.read.FIFO;
  692.         PUTCIRCBUF(CBYTE,(char*)(tempChar));
  693.         }
  694.         PUTCIRCNULL;
  695.     }
  696.     PUTCIRCBUF(CSTR,"msg-out: msg: ");
  697.     for (i=0; i<devPtr->messageBufLen; i++) {
  698.         circBuf[circHead] = ' ';
  699.         circHead = (circHead + 1) % CIRCBUFLEN;
  700.         PUTCIRCBUF(CBYTE, (char *)devPtr->messageBuf[i]);
  701.         regsPtr->scsi_ctrl.write.FIFO = devPtr->messageBuf[i];
  702.         devPtr->messageBuf[i] = '\0';
  703.     }
  704.     PUTCIRCNULL;
  705.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  706.     devPtr->lastPhase = PHASE_MSG_OUT;
  707.     devPtr->messageBufLen = 0;
  708.     status = regsPtr->scsi_ctrl.read.status;
  709.     if (status & SR_GE) {
  710.         panic("gross error 2");
  711.     }
  712.     break;
  713.     case SR_MSG_IN:
  714.     /* request incoming message xfer */
  715.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  716.     devPtr->lastPhase = PHASE_MSG_IN;
  717.     break;
  718.     default:
  719.     printf("unknown scsi phase type: 0x%02x\n", (int)phase);
  720.     status = FAILURE;
  721.     break;
  722.     }
  723.  
  724.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  725.     return TRUE;
  726. }
  727.  
  728. /*
  729.  *----------------------------------------------------------------------
  730.  *
  731.  * PerformCmdDone
  732.  *
  733.  *    Do cleanup after final phase of command.
  734.  *
  735.  * Results:
  736.  *    None.
  737.  *
  738.  * Side effects:
  739.  *    Calls RequestDone routine to invoke callback
  740.  *      and then gets next item of queue set.
  741.  *
  742.  *----------------------------------------------------------------------
  743.  */
  744. static void
  745. PerformCmdDone(ctrlPtr,status)
  746. Controller   *ctrlPtr;
  747. ReturnStatus status;
  748. {
  749.     List_Links        *newRequestPtr;
  750.     ClientData        clientData;
  751.  
  752.     ctrlPtr->regsPtr->scsi_ctrl.write.command = CR_EN_SLCT;
  753.     if (IS_CTRL_FREE(ctrlPtr)) {
  754.     if (ctrlPtr->interruptDevPtr == (Device *)NIL) {
  755.         newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  756.                         ctrlPtr->devQueuesMask,
  757.                         &clientData);
  758.         PUTCIRCBUF(CSTR,"cdone: cmd ");
  759.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  760.         PUTCIRCNULL;
  761.     } else {
  762.         clientData = (ClientData)(ctrlPtr->interruptDevPtr);
  763.         newRequestPtr=(List_Links *)(ctrlPtr->interruptDevPtr->scsiCmdPtr);
  764.         SET_DEV_FREE(ctrlPtr->interruptDevPtr);
  765.         ctrlPtr->interruptDevPtr = (Device *)NIL;
  766.         PUTCIRCBUF(CSTR,"cdone: resend dev ");
  767.         PUTCIRCBUF(CINT, (char *)clientData);
  768.         PUTCIRCBUF(CSTR," cmd ");
  769.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  770.         PUTCIRCNULL;
  771.     }
  772.     if (newRequestPtr != (List_Links *) NIL) {
  773.         (void) DevEntryAvailProc(clientData, newRequestPtr);
  774.     }
  775.     } else {
  776.     PUTCIRCBUF(CSTR,"cdone: busy ");
  777.     PUTCIRCNULL;
  778.     }
  779.  
  780. }
  781.  
  782. /*
  783.  *----------------------------------------------------------------------
  784.  *
  785.  * PerformSelect
  786.  *
  787.  *    Interpret select phase
  788.  *
  789.  * Results:
  790.  *    None.
  791.  *
  792.  * Side effects:
  793.  *    None.
  794.  *
  795.  *----------------------------------------------------------------------
  796.  */
  797. static ReturnStatus
  798. PerformSelect(ctrlPtr, interruptReg, sequenceReg)
  799. Controller      *ctrlPtr;
  800. unsigned int    interruptReg;
  801. unsigned int    sequenceReg;
  802. {
  803.     Device   *devPtr = ctrlPtr->devPtr;
  804.     static char *errMsg[] = {
  805.     "No error",
  806.     "target timed out",
  807.     "no message-out phase",
  808.     "no command phase",
  809.     "command phase incomplete",
  810.     "unknown sequence error"
  811.     };
  812.     int msgNum;
  813.     ReturnStatus status = SUCCESS;
  814.  
  815.     switch(sequenceReg) {
  816.     case SEQ_COMPLETE:
  817.     msgNum = 0;
  818.     break;
  819.     case SEQ_NO_SEL:
  820.     if (interruptReg & IR_DISCNCT) {
  821.         msgNum = 1;
  822.     } else if (!(devPtr->msgFlag & REQEXTENDEDMSG)) {
  823.         msgNum = 2;
  824.     } else {
  825.         msgNum = 0;
  826.         devPtr->msgFlag &= ~REQEXTENDEDMSG;
  827.         devPtr->messageBuf[0] = SCSI_EXTENDED_MESSAGE;
  828.         devPtr->messageBuf[1] = 3;
  829.         devPtr->messageBuf[2] = SCSI_EXTENDED_MSG_SYNC;
  830.         devPtr->messageBuf[3] = NCR_TO_SCSI(MIN_SYNCH_PERIOD);
  831.         devPtr->messageBuf[4] = MAX_SYNCH_OFFSET;
  832.         devPtr->messageBufLen = 5;
  833.     }
  834.     break;
  835.     case SEQ_NO_CMD:
  836.     msgNum = 3;
  837.     break;
  838.     case SEQ_CMD_INCOMPLETE:
  839.     msgNum = 4;
  840.     break;
  841.     default:
  842.     msgNum = 5;
  843.     break;
  844.     }
  845.     
  846.     if (msgNum) {
  847.     ctrlPtr->regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  848.     status = FAILURE;
  849.     printf("%s: selection failed: %s\n",
  850.            ctrlPtr->devPtr->handle.locationName,
  851.            errMsg[msgNum]);
  852.     }
  853.     
  854.     return status;
  855.  
  856. } 
  857.  
  858. /*
  859.  *----------------------------------------------------------------------
  860.  *
  861.  * PerformDataXfer
  862.  *
  863.  *    Interpret data-in, data-out condition
  864.  *
  865.  * Results:
  866.  *    None.
  867.  *
  868.  * Side effects:
  869.  *    None.
  870.  *
  871.  *----------------------------------------------------------------------
  872.  */
  873. static ReturnStatus
  874. PerformDataXfer(ctrlPtr, interruptReg, statusReg)
  875. Controller      *ctrlPtr;
  876. unsigned int    interruptReg;
  877. unsigned int    statusReg;
  878. {
  879.     ReturnStatus status = SUCCESS;
  880.     volatile CtrlRegs    *regsPtr = ctrlPtr->regsPtr;
  881.     Device         *devPtr = ctrlPtr->devPtr;
  882.     unsigned char  fifoCnt;
  883.     int            residual;
  884.     int           amountXfered;
  885.  
  886.     if (interruptReg & IR_DISCNCT) {
  887.     printf("%s disconnected or timed out during data xfer.\n",
  888.            devPtr->handle.locationName);
  889.     return DEV_TIMEOUT;
  890.     }
  891.  
  892. #ifdef sun4c
  893.     dmaControllerActive--;
  894.     MACH_DELAY(100);
  895. #endif
  896.     residual = regsPtr->scsi_ctrl.read.xCntLo;
  897. #ifdef sun4c
  898.     MACH_DELAY(100);
  899. #endif
  900.     residual += (regsPtr->scsi_ctrl.read.xCntHi << 8);
  901.     fifoCnt = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  902.     residual += fifoCnt;
  903.     /*
  904.      * If the transfer was the maximum, 64K bytes, a 0 in the counter
  905.      * may mean that nothing was transfered...  What should I do? XXX
  906.      */
  907.  
  908.     PUTCIRCBUF(CSTR,"residual: ");
  909.     PUTCIRCBUF(CINT,(char *)(residual));
  910.     PUTCIRCBUF(CSTR,"; fifoCnt ");
  911.     PUTCIRCBUF(CINT,(char *)(fifoCnt));
  912.     PUTCIRCNULL;
  913.     regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  914.  
  915.     /*
  916.      * Flush the cache on data in, since the dma put it into memory
  917.      * but didn't go through the cache.  We don't have to worry about this
  918.      * on writes, since the sparcstation has a write-through cache.
  919.      */
  920.     amountXfered = devPtr->activeBufLen - residual;
  921.     if (devPtr->lastPhase == PHASE_DATA_IN) {
  922.     FLUSH_BYTES((char *) ctrlPtr->buffer, devPtr->activeBufPtr, 
  923.             amountXfered);
  924.     }
  925.     devPtr->activeBufPtr += amountXfered;
  926.     devPtr->activeBufLen = residual;
  927.  
  928.     if (! (interruptReg & IR_BUS_SERV)) {
  929.     /* Target didn't request information transfer phase. */
  930.     printf("Didn't receive bus service signal after DMA xfer.\n");
  931.     status = FAILURE;
  932.     }
  933.  
  934.     return status;
  935.  
  936. }
  937.  
  938. /*
  939.  *----------------------------------------------------------------------
  940.  *
  941.  * PerformStatus
  942.  *
  943.  *    Interpret status condition
  944.  *
  945.  * Results:
  946.  *    None.
  947.  *
  948.  * Side effects:
  949.  *    None.
  950.  *
  951.  *----------------------------------------------------------------------
  952.  */
  953. static ReturnStatus
  954. PerformStatus(ctrlPtr, interruptReg)
  955. Controller      *ctrlPtr;
  956. unsigned int    interruptReg;
  957. {
  958.     volatile CtrlRegs    *regsPtr = ctrlPtr->regsPtr;
  959.     Device              *devPtr = ctrlPtr->devPtr;
  960.     int            numBytes;
  961.     unsigned            char message;
  962.  
  963.     devPtr->lastPhase = PHASE_STAT_MSG_IN;
  964.     /* Read bytes from FIFO. */
  965.     numBytes = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  966.     if (numBytes != 2) {
  967.     /* We didn't get both phases. */
  968.     printf("SCSIC90: Missing message byte after status phase byte.\n");
  969.     return(FAILURE);
  970.     }
  971.     devPtr->commandStatus = regsPtr->scsi_ctrl.read.FIFO;
  972.     devPtr->commandStatus &= SCSI_STATUS_MASK;
  973.     message = regsPtr->scsi_ctrl.read.FIFO;
  974.     if (! (interruptReg & IR_FUNC_COMP)) {
  975.     printf("SCSIC90: Command didn't complete.\n");
  976.     return(FAILURE);
  977.     }
  978.  
  979.     if (message != SCSI_COMMAND_COMPLETE) {
  980.     printf("SCSIC90: Expecting cmd_complete msg from %s, got ",
  981.            ctrlPtr->devPtr->handle.locationName);
  982.     PrintMsg((unsigned int) message);
  983.     return(FAILURE);
  984.     }
  985.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  986.     
  987.     return SUCCESS;
  988. }
  989.  
  990. /*
  991.  *----------------------------------------------------------------------
  992.  *
  993.  * PerformMsgIn
  994.  *
  995.  *    Interpret msg_in condition
  996.  *
  997.  * Results:
  998.  *    None.
  999.  *
  1000.  * Side effects:
  1001.  *    None.
  1002.  *
  1003.  *----------------------------------------------------------------------
  1004.  */
  1005. static ReturnStatus
  1006. PerformMsgIn(ctrlPtr)
  1007. Controller *ctrlPtr;
  1008. {
  1009.     ReturnStatus status = SUCCESS;
  1010.     Device *devPtr = ctrlPtr->devPtr;
  1011.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1012.     unsigned char message;
  1013.  
  1014.     message = regsPtr->scsi_ctrl.read.FIFO;
  1015.  
  1016.     PUTCIRCBUF(CSTR,"msg in: ");
  1017.     PUTCIRCBUF(CBYTE, (char *)message);
  1018.     PUTCIRCNULL;
  1019.  
  1020.     if (devPtr->msgFlag & STARTEXTENDEDMSG) { 
  1021.     status = PerformExtendedMsgIn(ctrlPtr,(unsigned int)message);
  1022.     return status;
  1023.     }
  1024.  
  1025.     switch(message) {
  1026.     case SCSI_COMMAND_COMPLETE:
  1027.     /* this is handled in that stat_msg_in phase */
  1028.     printf("not expecting command_complete msg.\n");
  1029.     status = FAILURE;
  1030.     break;
  1031.     case SCSI_DISCONNECT:
  1032.     devPtr->lastPhase = PHASE_RDY_DISCON;
  1033.     break;
  1034.     case SCSI_SAVE_DATA_POINTER:
  1035.     /* No need to save anything since we keep the current
  1036.      * data ptr in activeBufPtr anyway. */
  1037.     devPtr->lastPhase = PHASE_BUS_FREE;
  1038.     PUTCIRCBUF(CSTR,"save: ptr ");
  1039.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufPtr);
  1040.     PUTCIRCBUF(CSTR,"; len ");
  1041.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufLen);
  1042.     PUTCIRCNULL;
  1043.     break;
  1044.     case SCSI_RESTORE_POINTERS:
  1045.     /* No need to restore anything, since we keep the
  1046.      * current data ptr in activeBufPtr anyway. */
  1047.     devPtr->lastPhase = PHASE_BUS_FREE;
  1048.     PUTCIRCBUF(CSTR,"restore: ptr ");
  1049.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufPtr);
  1050.     PUTCIRCBUF(CSTR,"; len ");
  1051.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufLen);
  1052.     PUTCIRCNULL;
  1053.     break;
  1054.     case SCSI_IDENTIFY:
  1055.     devPtr->lastPhase = PHASE_BUS_FREE;
  1056.     break;
  1057.     case SCSI_EXTENDED_MESSAGE:
  1058.     devPtr->msgFlag |= STARTEXTENDEDMSG;
  1059.     status = PerformExtendedMsgIn(ctrlPtr,(unsigned int)message);
  1060.     return status;
  1061.     break;
  1062.     case SCSI_MESSAGE_REJECT:
  1063.     /* kill any synchronous agreement in effect */
  1064.     devPtr->synchPeriod = MIN_SYNCH_PERIOD;
  1065.     devPtr->synchOffset = 0;
  1066.     devPtr->lastPhase = PHASE_BUS_FREE;
  1067.     devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1068.     break;
  1069.     default:
  1070.     PUTCIRCBUF(CSTR,"Msg-in: unknown msg");
  1071.     PUTCIRCNULL;
  1072.     printf("SCSIC90: Couldn't handle msg type: 0x%02x\n",message);
  1073.     regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1074.     devPtr->lastPhase = PHASE_BUS_FREE;
  1075.     break;
  1076.     }
  1077.  
  1078.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1079.  
  1080.     return status;
  1081.  
  1082. } /* PerformMsgIn */
  1083.  
  1084. /*
  1085.  *----------------------------------------------------------------------
  1086.  *
  1087.  * PerformExtendedMsgIn
  1088.  *
  1089.  *    Interpret extended msg_in condition
  1090.  *
  1091.  * Results:
  1092.  *    status.
  1093.  *
  1094.  * Side effects:
  1095.  *      Sets the values for synchronous xfer in the device structure.
  1096.  *
  1097.  *    We get the bytes of the extended msg 1 at a time.
  1098.  *      Format: extended msg indicator : 0x01 
  1099.  *                       msg length    : 0x?? 
  1100.  *                       msg code      : 0x03 (we only do 1 type) 
  1101.  *                       msg param1    : 0x?? (should be synch_period)
  1102.  *                       msg param2    : 0x?? (should be synch_offset)
  1103.  *
  1104.  *----------------------------------------------------------------------
  1105.  */
  1106. static ReturnStatus
  1107. PerformExtendedMsgIn(ctrlPtr, message)
  1108. Controller *ctrlPtr;
  1109. unsigned int message;
  1110. {
  1111.     ReturnStatus status = SUCCESS;
  1112.     Device *devPtr      = ctrlPtr->devPtr;
  1113.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1114.     int len             = devPtr->messageBufLen;
  1115.     unsigned char periodInClks;
  1116.     unsigned char period;
  1117.     unsigned char offset;
  1118.     int i;
  1119.  
  1120.     devPtr->messageBuf[len] = message;
  1121.     devPtr->messageBufLen++;
  1122.  
  1123.     switch(len) {
  1124.     case 0: /* extended msg code 0x01 */
  1125.     devPtr->lastPhase = PHASE_BUS_FREE;
  1126.     break;
  1127.     case 1: /* msg length. i.e. # bytes to follow this one */
  1128.     devPtr->lastPhase = PHASE_BUS_FREE;
  1129.     break;
  1130.     case 2: /* extended msg code */
  1131.     if ((message != SCSI_EXTENDED_MSG_SYNC) ||
  1132.         (devPtr->messageBuf[1] != 3)) {
  1133.         PUTCIRCBUF(CSTR,"Msg-in: bad xtend msg: ");
  1134.         PUTCIRCBUF(CBYTE,(char *)(message));
  1135.         PUTCIRCBUF(CSTR,"; len ");
  1136.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[1]));
  1137.         PUTCIRCNULL;
  1138.         panic("bad xtend msg");
  1139.         devPtr->messageBuf[0] = SCSI_MESSAGE_REJECT;
  1140.         devPtr->messageBufLen = 1;
  1141.         regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1142.         devPtr->lastPhase = PHASE_MSG_OUT;
  1143.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1144.     } else {
  1145.         devPtr->lastPhase = PHASE_BUS_FREE;
  1146.     }
  1147.     break;
  1148.     case 3: /* synch_period */
  1149.     devPtr->lastPhase = PHASE_BUS_FREE;
  1150.     break;
  1151.     case 4: /* synch_offset */
  1152.     /* 
  1153.      * Now we have both the period and the offset.
  1154.      */
  1155.     period = devPtr->messageBuf[3];
  1156.     offset = devPtr->messageBuf[4];
  1157.     periodInClks = SCSI_TO_NCR(period);
  1158.     /* if values are acceptable, install them else negotiate */
  1159.     if ((periodInClks >= MIN_SYNCH_PERIOD) &&
  1160.         (offset <= MAX_SYNCH_OFFSET)) {
  1161.         PUTCIRCBUF(CSTR,"accept per: ");
  1162.         PUTCIRCBUF(CBYTE,(char *)period);
  1163.         PUTCIRCBUF(CSTR,"; per clk ");
  1164.         PUTCIRCBUF(CBYTE,(char *)periodInClks);
  1165.         PUTCIRCBUF(CSTR,"; off ");
  1166.         PUTCIRCBUF(CBYTE,(char *)offset);
  1167.         PUTCIRCNULL;
  1168.         devPtr->synchPeriod = periodInClks; 
  1169.         devPtr->synchOffset = offset;
  1170.         devPtr->lastPhase = PHASE_BUS_FREE;
  1171.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1172.     } else {
  1173.         if (periodInClks < devPtr->synchPeriod) {
  1174.         devPtr->messageBuf[3] = NCR_TO_SCSI(MIN_SYNCH_PERIOD);
  1175.         }
  1176.         if (offset > devPtr->synchOffset) {
  1177.         devPtr->messageBuf[4] = MAX_SYNCH_OFFSET;
  1178.         }
  1179.         PUTCIRCBUF(CSTR,"negotiate per: ");
  1180.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[3]));
  1181.         PUTCIRCBUF(CSTR,"; off ");
  1182.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[4]));
  1183.         PUTCIRCNULL;
  1184.         regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1185.         devPtr->lastPhase = PHASE_MSG_OUT;
  1186.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1187.     }
  1188.     break;
  1189.     default:
  1190.     printf("SCSIC90: xmsg case error\n");
  1191.     devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1192.     status = FALSE;
  1193.     break;
  1194.     }
  1195.     PUTCIRCBUF(CSTR,"Xmsg-in: accept msg");
  1196.     len = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  1197.     PUTCIRCBUF(CSTR,"; FIFO:");
  1198.     for(i=0;i<len;i++) {
  1199.     circBuf[circHead] = ' ';
  1200.     circHead = (circHead + 1) % CIRCBUFLEN;
  1201.     offset = regsPtr->scsi_ctrl.read.FIFO;
  1202.     PUTCIRCBUF(CBYTE, (char *)offset);
  1203.     }
  1204.     PUTCIRCBUF(CSTR,"; mbuf:");
  1205.     for(i=0;i<devPtr->messageBufLen;i++) {
  1206.     circBuf[circHead] = ' ';
  1207.     circHead = (circHead + 1) % CIRCBUFLEN;
  1208.     PUTCIRCBUF(CBYTE, (char *)(devPtr->messageBuf[i]));
  1209.     }
  1210.     PUTCIRCNULL;
  1211.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1212.     return status;
  1213. } 
  1214.  
  1215. /*
  1216.  *----------------------------------------------------------------------
  1217.  *
  1218.  * PerformReselect
  1219.  *
  1220.  *    Reconnect a logical unit
  1221.  *
  1222.  * Results:
  1223.  *    None.
  1224.  *
  1225.  * Side effects:
  1226.  *    None.
  1227.  *
  1228.  *----------------------------------------------------------------------
  1229.  */
  1230. static ReturnStatus
  1231. PerformReselect(ctrlPtr, interruptReg)
  1232. Controller      *ctrlPtr;
  1233. unsigned int    interruptReg;
  1234. {
  1235.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1236.     Device            *devPtr;
  1237.     unsigned char     target;
  1238.     unsigned char     ourID;
  1239.     unsigned char     message;
  1240.     int               fifoCnt,i;
  1241.  
  1242.     /* The ID of the target which is requesting reselection comes over 
  1243.      * the bus encoded, not 0-7.  The encoding is the logical OR of 
  1244.      * two bytes: one with the i'th bit set (for target #i) and
  1245.      * one with the host's bit set (usually #7). Unfortunately,
  1246.      * the host's ID is kindly provided to us in binary so we perform
  1247.      * a little transformation...
  1248.      */
  1249.     target = regsPtr->scsi_ctrl.read.FIFO;
  1250.     ourID = regsPtr->scsi_ctrl.read.config1 & C1_BUS_ID;
  1251.     ourID = ~(1 << ourID);
  1252.  
  1253.     switch(target & ourID) {
  1254.     case 0x01:
  1255.     target = 0;
  1256.     break;
  1257.     case 0x02:
  1258.     target = 1;
  1259.     break;
  1260.     case 0x04:
  1261.     target = 2;
  1262.     break;
  1263.     case 0x08:
  1264.     target = 3;
  1265.     break;
  1266.     case 0x10:
  1267.     target = 4;
  1268.     break;
  1269.     case 0x20:
  1270.     target = 5;
  1271.     break;
  1272.     case 0x40:
  1273.     target = 6;
  1274.     break;
  1275.     case 0x80:
  1276.     target = 7;
  1277.     break;
  1278.     default:
  1279.     printf("SCSIC90: couldn't decode target ID 0x%02x\n", target);
  1280.     return FAILURE;
  1281.     }
  1282.  
  1283.     message = regsPtr->scsi_ctrl.read.FIFO;    
  1284.  
  1285.     if (!(message & SCSI_IDENTIFY)) {
  1286.     printf("SCSIC90: Expected Identify msg after reselect, got 0x%02x.\n",
  1287.            message);
  1288.     return FAILURE;
  1289.     }
  1290.     message &= SCSI_IDENT_LUN_MASK;
  1291.  
  1292.     devPtr = ctrlPtr->devicePtr[target][message];
  1293.  
  1294.     fifoCnt = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  1295.     PUTCIRCBUF(CSTR,"resel: targ ");
  1296.     PUTCIRCBUF(CBYTE, (char *)target);
  1297.     PUTCIRCBUF(CSTR,"; lun ");
  1298.     PUTCIRCBUF(CBYTE, (char *)message);
  1299.     ourID = regsPtr->scsi_ctrl.read.command;
  1300.     PUTCIRCBUF(CSTR,"; cmdreg:");
  1301.     PUTCIRCBUF(CBYTE,(char *)ourID);
  1302.     PUTCIRCBUF(CSTR,"; FIFO:");
  1303.     for(i=0;i<fifoCnt;i++) {
  1304.     circBuf[circHead] = ' ';
  1305.     circHead = (circHead + 1) % CIRCBUFLEN;
  1306.     ourID = regsPtr->scsi_ctrl.read.FIFO;
  1307.     PUTCIRCBUF(CBYTE, (char *)ourID);
  1308.     }
  1309.     PUTCIRCNULL;
  1310.  
  1311.     if (IS_DEV_FREE(devPtr)) {
  1312.     panic("resel: device is free.\n");
  1313.     }
  1314.  
  1315.     /*
  1316.      * It's possible for the reselection interrupt to occur just
  1317.      * when we were sending a new command.  Three cases:
  1318.      *  1) Interrupt happened before loading any cmd bytes.
  1319.      *     Only indication is that controller is busy.
  1320.      *  2) Interrupt happened before the send; part of the
  1321.      *     cmd in the fifo.
  1322.      *  3) Interrupt happened during the arbitration/selection
  1323.      *     phases of the send; the bus_serv bit will be set.
  1324.      * Note that the 53C90 doesn't handle this situation quite
  1325.      * the same as the later 53C94, 53C95 chips. The older chip
  1326.      * accepts cmd bytes after it shouldn't so there may be bytes
  1327.      * in the FIFO now that should be here. See the manual.
  1328.      */
  1329.  
  1330.  
  1331.     /* An restore_data_ pointer cmd is implied by a reselect
  1332.      * but we don't need to do anything */
  1333.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1334.  
  1335.     if (!(IS_CTRL_FREE(ctrlPtr)) ||
  1336.     (interruptReg & IR_BUS_SERV) ||
  1337.     (fifoCnt > 0)) {
  1338.     PUTCIRCBUF(CSTR,"resel: save dev ");
  1339.     PUTCIRCBUF(CINT, (char *)ctrlPtr->devPtr);
  1340.     PUTCIRCBUF(CSTR," cmd ");
  1341.     PUTCIRCBUF(CINT, (char *)ctrlPtr->devPtr->scsiCmdPtr);
  1342.     PUTCIRCNULL;
  1343.     ctrlPtr->interruptDevPtr = ctrlPtr->devPtr;
  1344.     regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  1345.     }
  1346.  
  1347.     SET_CTRL_BUSY(ctrlPtr,devPtr);
  1348.  
  1349.     return SUCCESS;
  1350. }
  1351.  
  1352. /*
  1353.  *----------------------------------------------------------------------
  1354.  *
  1355.  * ReleaseProc --
  1356.  *
  1357.  *    Device release proc for controller.
  1358.  *
  1359.  * Results:
  1360.  *    None.
  1361.  *
  1362.  * Side effects:
  1363.  *    None.
  1364.  *
  1365.  *----------------------------------------------------------------------
  1366.  */
  1367. /*ARGSUSED*/
  1368. static ReturnStatus
  1369. ReleaseProc(scsiDevicePtr)
  1370.     ScsiDevice    *scsiDevicePtr;
  1371. {
  1372.     return SUCCESS;
  1373. }
  1374.  
  1375.  
  1376. /*
  1377.  *----------------------------------------------------------------------
  1378.  *
  1379.  * DevSCSIC90AttachDevice --
  1380.  *
  1381.  *    Attach a SCSI device using the Sun SCSIC90 HBA. 
  1382.  *
  1383.  * Results:
  1384.  *    None.
  1385.  *
  1386.  * Side effects:
  1387.  *    None.
  1388.  *
  1389.  *----------------------------------------------------------------------
  1390.  */
  1391.  
  1392. ScsiDevice   *
  1393. DevSCSIC90AttachDevice(devicePtr, insertProc)
  1394.     Fs_Device    *devicePtr;     /* Device to attach. */
  1395.     void    (*insertProc)(); /* Queue insert procedure. */
  1396. {
  1397.     Device *devPtr;
  1398.     Controller    *ctrlPtr;
  1399.     char   tmpBuffer[512];
  1400.     int       length;
  1401.     int       ctrlNum;
  1402.     int       targetID, lun;
  1403.  
  1404.     /*
  1405.      * First find the SCSIC90 controller this device is on.
  1406.      */
  1407.     ctrlNum = SCSI_HBA_NUMBER(devicePtr);
  1408.     if ((ctrlNum > MAX_SCSIC90_CTRLS) ||
  1409.     (Controllers[ctrlNum] == (Controller *) 0)) { 
  1410.     return (ScsiDevice  *) NIL;
  1411.     } 
  1412.     ctrlPtr = Controllers[ctrlNum];
  1413.     targetID = SCSI_TARGET_ID(devicePtr);
  1414.     lun = SCSI_LUN(devicePtr);
  1415.     /*
  1416.      * Allocate a device structure for the device and fill in the
  1417.      * handle part. This must be created before we grap the MASTER_LOCK.
  1418.      */
  1419.     devPtr = (Device *) malloc(sizeof(Device)); 
  1420.     bzero((char *) devPtr, sizeof(Device));
  1421.     devPtr->handle.devQueue = Dev_QueueCreate(ctrlPtr->devQueues,
  1422.                           (1<<targetID),
  1423.                           insertProc,
  1424.                           (ClientData) devPtr);
  1425.     devPtr->handle.locationName = "Unknown";
  1426.     devPtr->handle.LUN = lun;
  1427.     devPtr->handle.releaseProc = ReleaseProc;
  1428.     devPtr->handle.maxTransferSize = MAX_TRANSFER_SIZE;
  1429.     devPtr->targetID = targetID;
  1430.     devPtr->ctrlPtr = ctrlPtr;
  1431.     devPtr->synchPeriod = 0;
  1432.     devPtr->synchOffset = 0;
  1433.     devPtr->msgFlag = 0;
  1434.     MASTER_LOCK(&(ctrlPtr->mutex));
  1435.     /*
  1436.      * A device pointer of zero means that targetID/LUN 
  1437.      * conflicts with that of the HBA. A NIL means the
  1438.      * device hasn't been attached yet.
  1439.      */
  1440.     if (ctrlPtr->devicePtr[targetID][lun] == (Device *) 0) {
  1441.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1442.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  1443.     free((char *) devPtr);
  1444.     return (ScsiDevice *) NIL;
  1445.     }
  1446.     if (ctrlPtr->devicePtr[targetID][lun] != (Device *) NIL) {
  1447.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1448.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  1449.     free((char *) devPtr);
  1450.     return (ScsiDevice *) (ctrlPtr->devicePtr[targetID][lun]);
  1451.     }
  1452.     SET_DEV_FREE(devPtr);
  1453.     ctrlPtr->devicePtr[targetID][lun] = devPtr;
  1454.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1455.     (void) sprintf(tmpBuffer, "%s Target %d LUN %d", ctrlPtr->name, 
  1456.             devPtr->targetID, devPtr->handle.LUN);
  1457.     length = strlen(tmpBuffer);
  1458.     devPtr->handle.locationName = (char *) strcpy(malloc(length+1),tmpBuffer);
  1459.  
  1460.     if (devSCSIC90Debug > 3) {
  1461.     printf("devSCSIC90Attach: attached device %s.\n", tmpBuffer);
  1462.     }
  1463.  
  1464.     return (ScsiDevice *) devPtr;
  1465. }
  1466.  
  1467.  
  1468. /*
  1469.  *----------------------------------------------------------------------
  1470.  *
  1471.  * PrintMsg --
  1472.  *
  1473.  *    Print out the asci string for a scsi msg.
  1474.  *
  1475.  * Results:
  1476.  *    None.
  1477.  *
  1478.  * Side effects:
  1479.  *    None.
  1480.  *
  1481.  *----------------------------------------------------------------------
  1482.  */
  1483. static void
  1484. PrintMsg(msg)
  1485.     unsigned int msg;
  1486. {
  1487.  
  1488.     if (msg & SCSI_IDENTIFY) {
  1489.     if (msg & SCSI_DIS_REC_IDENTIFY) {
  1490.         printf("dis_rec_identify (LUN 0x%02x) msg.\n",
  1491.            (int)(msg & SCSI_IDENT_LUN_MASK));
  1492.     } else {
  1493.         printf("identify (LUN 0x%02x) msg.\n",
  1494.            (int)(msg & SCSI_IDENT_LUN_MASK));
  1495.     }
  1496.     return;
  1497.     } 
  1498.  
  1499.     switch (msg) {
  1500.     case SCSI_COMMAND_COMPLETE:
  1501.     printf("command_complete msg.\n");
  1502.     break;
  1503.     case SCSI_SAVE_DATA_POINTER:
  1504.     printf("save_data_ptr msg.\n");
  1505.     break;
  1506.     case SCSI_RESTORE_POINTERS:
  1507.     printf("restore_ptrs msg.\n");
  1508.     break;
  1509.     case SCSI_DISCONNECT:
  1510.     printf("disconnect msg.\n");
  1511.     break;
  1512.     case SCSI_ABORT:
  1513.     printf("abort msg.\n");
  1514.     break;
  1515.     case SCSI_MESSAGE_REJECT:
  1516.     printf("msg_reject msg.\n");
  1517.     break;
  1518.     case SCSI_NO_OP:
  1519.     printf("no_op msg.\n");
  1520.     break;
  1521.     case SCSI_MESSAGE_PARITY_ERROR:
  1522.     printf("msg_parity msg.\n");
  1523.     break;
  1524.     case SCSI_BUS_RESET:
  1525.     printf("bus_reset msg.\n");
  1526.     break;
  1527.     default:
  1528.     printf("unknown msg %d.\n", msg);
  1529.     break;
  1530.     }
  1531.  
  1532.     return;
  1533. }
  1534.  
  1535.  
  1536. /*
  1537.  *----------------------------------------------------------------------
  1538.  *
  1539.  * PrintPhase --
  1540.  *
  1541.  *    Print out the asci string for a scsi phase.
  1542.  *
  1543.  * Results:
  1544.  *    None.
  1545.  *
  1546.  * Side effects:
  1547.  *    None.
  1548.  *
  1549.  *----------------------------------------------------------------------
  1550.  */
  1551. static void
  1552. PrintPhase(phase)
  1553.     unsigned int    phase;
  1554. {
  1555.     
  1556.     switch (phase) {
  1557.     case SR_DATA_OUT:
  1558.     printf("data out phase.\n");
  1559.     break;
  1560.     case SR_DATA_IN:
  1561.     printf("data in phase.\n");
  1562.     break;
  1563.     case SR_COMMAND:
  1564.     printf("command phase.\n");
  1565.     break;
  1566.     case SR_STATUS:
  1567.     printf("status phase.\n");
  1568.     break;
  1569.     case SR_MSG_OUT:
  1570.     printf("msg out phase.\n");
  1571.     break;
  1572.     case SR_MSG_IN:
  1573.     printf("msg in phase.\n");
  1574.     break;
  1575.     default:
  1576.     printf("unknown phase %d.\n", phase);
  1577.     break;
  1578.     }
  1579.  
  1580.     return;
  1581. }
  1582.  
  1583. /*
  1584.  *----------------------------------------------------------------------
  1585.  *
  1586.  * PrintLastPhase --
  1587.  *
  1588.  *    Print out the asci string for the last scsi phase we were in.
  1589.  *
  1590.  * Results:
  1591.  *    None.
  1592.  *
  1593.  * Side effects:
  1594.  *    None.
  1595.  *
  1596.  *----------------------------------------------------------------------
  1597.  */
  1598. static void
  1599. PrintLastPhase(phase)
  1600.     unsigned int    phase;
  1601. {
  1602.     switch (phase) {
  1603.     case PHASE_BUS_FREE:
  1604.     printf("bus free phase.\n");
  1605.     break;
  1606.     case PHASE_SELECTION:
  1607.     printf("selection phase.\n");
  1608.     break;
  1609.     case PHASE_DATA_OUT:
  1610.     printf("data out phase.\n");
  1611.     break;
  1612.     case PHASE_DATA_IN:
  1613.     printf("data in phase.\n");
  1614.     break;
  1615.     case PHASE_STATUS:
  1616.     printf("status phase.\n");
  1617.     break;
  1618.     case PHASE_MSG_IN:
  1619.     printf("msg in phase.\n");
  1620.     break;
  1621.     case PHASE_STAT_MSG_IN:
  1622.     printf("stat_msg in phase.\n");
  1623.     break;
  1624.     case PHASE_RDY_DISCON:
  1625.     printf("rdy_discon phase.\n");
  1626.     break;
  1627.     default:
  1628.     printf("unknown phase %d.\n", phase);
  1629.     break;
  1630.     }
  1631.  
  1632.     return;
  1633. }
  1634.  
  1635.  
  1636. /*
  1637.  *----------------------------------------------------------------------
  1638.  *
  1639.  * PrintRegs --
  1640.  *
  1641.  *    Print out the interesting registers.  This could be a macro but
  1642.  *    then it couldn't be called from kdbx.  This routine is necessary
  1643.  *    because kdbx doesn't print all the character values properly.
  1644.  *
  1645.  * Results:
  1646.  *    None.
  1647.  *
  1648.  * Side effects:
  1649.  *    Data is displayed on the console or to the debugger.
  1650.  *
  1651.  *----------------------------------------------------------------------
  1652.  */
  1653. static void
  1654. PrintRegs(regsPtr)
  1655.     register volatile CtrlRegs *regsPtr;
  1656. {
  1657.  
  1658.     printf("Won't print interrupt register since that would clear it.\n");
  1659.     printf("xCntLow: 0x%x, xCntHi: 0x%x, FIFO: 0x%x, command: 0x%x,\n",
  1660.         regsPtr->scsi_ctrl.read.xCntLo,
  1661.         regsPtr->scsi_ctrl.read.xCntHi,
  1662.         regsPtr->scsi_ctrl.read.FIFO,
  1663.         regsPtr->scsi_ctrl.read.command);
  1664.     printf("status: 0x%x, sequence: 0x%x, FIFOFlags: 0x%x, config1: 0x%x,\n",
  1665.         regsPtr->scsi_ctrl.read.status,
  1666.         regsPtr->scsi_ctrl.read.sequence,
  1667.         regsPtr->scsi_ctrl.read.FIFOFlags,
  1668.         regsPtr->scsi_ctrl.read.config1);
  1669.     printf("config2: 0x%x, config3: 0x%x\n",
  1670.         regsPtr->scsi_ctrl.read.config2,
  1671.         regsPtr->scsi_ctrl.read.config3);
  1672.  
  1673.     return;
  1674. }
  1675.  
  1676.  
  1677. /*
  1678.  *----------------------------------------------------------------------
  1679.  *
  1680.  *  SpecialSenseProc --
  1681.  *
  1682.  *    Special function used for HBA generated REQUEST SENSE. A SCSI
  1683.  *    command request with this function as a call back proc will
  1684.  *    be processed by routine RequestDone as a result of a 
  1685.  *    REQUEST SENSE. This routine is never called.
  1686.  *
  1687.  * Results:
  1688.  *    None.
  1689.  *
  1690.  * Side effects:
  1691.  *    None.
  1692.  *
  1693.  *----------------------------------------------------------------------
  1694.  */
  1695.  
  1696. static int
  1697. SpecialSenseProc()
  1698. {
  1699.     return 0;
  1700. }
  1701.  
  1702.  
  1703. /*
  1704.  *----------------------------------------------------------------------
  1705.  *
  1706.  * Dev_ChangeScsiDebugLevel --
  1707.  *
  1708.  *    Change the level of debugging info for this scsi driver.
  1709.  *
  1710.  * Results:
  1711.  *    None.
  1712.  *
  1713.  * Side effects:
  1714.  *    A larger or lesser number of messages will be printed out.
  1715.  *
  1716.  *----------------------------------------------------------------------
  1717.  */
  1718. void
  1719. Dev_ChangeScsiDebugLevel(level)
  1720.     int    level;
  1721. {
  1722.     
  1723.     printf("Changing scsi debug level: was %d, ", devSCSIC90Debug);
  1724.     devSCSIC90Debug = level;
  1725.     printf("and is now %d.\n", devSCSIC90Debug);
  1726.  
  1727.     return;
  1728. }
  1729.  
  1730.  
  1731. /*
  1732.  *----------------------------------------------------------------------
  1733.  *
  1734.  * PutCircBuf
  1735.  *
  1736.  *    Stuff data into the circular log buffer
  1737.  *
  1738.  * Results:
  1739.  *    None.
  1740.  *
  1741.  * Side effects:
  1742.  *      None.
  1743.  *
  1744.  *----------------------------------------------------------------------
  1745.  */
  1746. static void
  1747. PutCircBuf(type, object)
  1748. int type;
  1749. char *object;
  1750. {
  1751.     int num = (int)object;
  1752.  
  1753.     switch(type) {
  1754.     case CSTR:
  1755.     while(*object) {
  1756.         circBuf[circHead] = *object++;
  1757.         circHead = (circHead + 1) % CIRCBUFLEN;
  1758.     }
  1759.     break;
  1760.     case CBYTE:
  1761.     circBuf[circHead] = CVTHEX(num,4);
  1762.     circHead = (circHead + 1) % CIRCBUFLEN;
  1763.     circBuf[circHead] = CVTHEX(num,0);
  1764.     circHead = (circHead + 1) % CIRCBUFLEN;
  1765.     break;
  1766.     case CINT:
  1767.     circBuf[circHead] = CVTHEX(num,28); 
  1768.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1769.     circBuf[circHead] = CVTHEX(num,24); 
  1770.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1771.     circBuf[circHead] = CVTHEX(num,20); 
  1772.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1773.     circBuf[circHead] = CVTHEX(num,16); 
  1774.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1775.     circBuf[circHead] = CVTHEX(num,12); 
  1776.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1777.     circBuf[circHead] = CVTHEX(num,8); 
  1778.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1779.     circBuf[circHead] = CVTHEX(num,4); 
  1780.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1781.     circBuf[circHead] = CVTHEX(num,0); 
  1782.     circHead = (circHead + 1) % CIRCBUFLEN;
  1783.     break;
  1784.     default:
  1785.     panic("PutCircBuf: unknown type\n");
  1786.     break;
  1787.     }
  1788. }
  1789.  
  1790.